/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/*
 * PanelMain.java
 *
 * Created on 11/10/2010, 12:30:27 AM
 */
package interfaz;

import interfaz.FuncionPanels.ecuaciones.PanelBiseccion;
import interfaz.FuncionPanels.ecuaciones.PanelEcuaciones;
import interfaz.FuncionPanels.PanelEliminacionGaussiana;
import interfaz.FuncionPanels.PanelFactorizacionLU;
import interfaz.FuncionPanels.ecuaciones.PanelIncrementales;
import interfaz.FuncionPanels.PanelInterNewton;
import interfaz.FuncionPanels.PanelInterpolacion;
import interfaz.FuncionPanels.PanelIterativosAbiertos;
import interfaz.FuncionPanels.PanelLagrange;
import interfaz.FuncionPanels.PanelMatriz;
import interfaz.FuncionPanels.ecuaciones.PanelNewton;
import interfaz.FuncionPanels.ecuaciones.PanelPuntoFijo;
import interfaz.FuncionPanels.ecuaciones.PanelRaices;
import interfaz.FuncionPanels.ecuaciones.PanelReglaFalsa;
import interfaz.FuncionPanels.ecuaciones.PanelSecante;
import interfaz.FuncionPanels.PanelSplinesCuadraticos;
import interfaz.FuncionPanels.PanelSplinesCubicos;
import interfaz.FuncionPanels.PanelSplinesLineales;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JSeparator;
import org.jdesktop.swingx.JXHyperlink;
import org.jdesktop.swingx.JXTaskPane;

/**
 * Clase que muestra el panel principal de la aplicacion.
 * <p> Este panel contiene los elementos necesarios para mostrar la funcionalidad de la aplicacion.
 * @author The NuMethod Team
 */
public class PanelMain extends javax.swing.JPanel implements ActionListener {

    NuMethodApp parent;
    //Variables de Instancia
    //Contenedores colapsables
    JXTaskPane TaskPaneNoLineales;
    JXTaskPane TaskPaneSisEcuaciones;
    JXTaskPane TaskPaneInterpolacion;
    //Hyperlinks de aplicacion
    JXHyperlink XLinkEcuaciones;
    JXHyperlink XLinkIncrementales;
    JXHyperlink XLinkBiseccion;
    JXHyperlink XLinkReglaFalsa;
    JXHyperlink XLinkPuntoFijo;
    JXHyperlink XLinkNewton;
    JXHyperlink XLinkSecante;
    JXHyperlink XLinkRaicesMultiples;
    JXHyperlink XLinkMatriz;
    JXHyperlink XLinkEliminacionGaussiana;
    JXHyperlink XLinkFactorizacionLU;
    JXHyperlink XLinkIterativosAbiertos;
    JXHyperlink XLinkInterpolacion;
    JXHyperlink XLinkInterNewton;
    JXHyperlink XLinkLagrange;
    JXHyperlink XLinkSplinesLineales;
    JXHyperlink XLinkSplinesCuadraticos;
    JXHyperlink XLinkSplinesCubicos;

    JXHyperlink returns;
    //Paneles para todos los metodos
    PanelEcuaciones panelEcuaciones;
    PanelIncrementales panelIncrementales;
    PanelBiseccion panelBiseccion;
    PanelReglaFalsa panelReglaFalsa;
    PanelPuntoFijo panelPuntoFijo;
    PanelNewton panelNewton;
    PanelSecante panelSecante;
    PanelRaices panelRaices;
    PanelMatriz panelMatriz;
    PanelEliminacionGaussiana panelEliminacionGaussiana;
    PanelFactorizacionLU panelFactorizacionLU;
    PanelIterativosAbiertos panelIterativosAbiertos;
    PanelInterpolacion panelInterpolacion;
    PanelInterNewton panelInterNewton;
    PanelLagrange panelLagrange;
    PanelSplinesLineales panelSplinesLineales;
    PanelSplinesCuadraticos panelSplinesCuadraticos;
    PanelSplinesCubicos panelSplinesCubicos;
    CardLayout cl;
    //Constantes de uso de la aplicacion
    public static final int ECUACIONES = 0;
    public static final int INCREMENTALES = 1;
    public static final int BISECCION = 2;
    public static final int REGLA_FALSA = 3;
    public static final int PUNTO_FIJO = 4;
    public static final int NEWTON = 5;
    public static final int SECANTE = 6;
    public static final int RAICES_MULTIPLES = 7;
    public static final int MATRICES = 10;
    public static final int ELIMINACION_GAUSSIANA = 11;
    public static final int FACTORIZACION_LU = 12;
    public static final int ITERATIVOS_ABIERTOS = 13;
    public static final int INTERPOLACION = 20;
    public static final int INTER_NEWTON = 21;
    public static final int LAGRANGE = 22;
    public static final int SPLINES_LINEALES = 23;
    public static final int SPLINES_CUADRATICOS = 24;
    public static final int SPLINES_CUBICOS = 25;

    /** Creates new form PanelMain */
    public PanelMain(NuMethodApp parent) {
        this.parent = parent;
        initComponents();
        initComponents2();
    }

    // <editor-fold defaultstate="collapsed" desc="HelpFul Getters">
    public JXTaskPane getTaskPaneInterpolacion() {
        return TaskPaneInterpolacion;
    }

    public JXTaskPane getTaskPaneNoLineales() {
        return TaskPaneNoLineales;
    }

    public JXTaskPane getTaskPaneSisEcuaciones() {
        return TaskPaneSisEcuaciones;
    }// </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="More helpful Getters">
    public JXHyperlink getXLinkBiseccion() {
        return XLinkBiseccion;
    }

    public JXHyperlink getXLinkEcuaciones() {
        return XLinkEcuaciones;
    }

    public JXHyperlink getXLinkIncrementales() {
        return XLinkIncrementales;
    }

    public JXHyperlink getXLinkMatriz() {
        return XLinkMatriz;
    }

    public JXHyperlink getXLinkNewton() {
        return XLinkNewton;
    }

    public PanelBiseccion getPanelBiseccion() {
        return panelBiseccion;
    }

    public PanelEcuaciones getPanelEcuaciones() {
        return panelEcuaciones;
    }

    public PanelIncrementales getPanelIncrementales() {
        return panelIncrementales;
    }

    public PanelMatriz getPanelMatriz() {
        return panelMatriz;
    }

    public PanelNewton getPanelNewton() {
        return panelNewton;
    }

    // </editor-fold>
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jScrollPane1 = new javax.swing.JScrollPane();
        TaskContainer = new org.jdesktop.swingx.JXTaskPaneContainer();
        PanelFuncion = new javax.swing.JPanel();

        jScrollPane1.setViewportView(TaskContainer);

        PanelFuncion.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
        PanelFuncion.setLayout(new java.awt.CardLayout());

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 236, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(PanelFuncion, javax.swing.GroupLayout.DEFAULT_SIZE, 638, Short.MAX_VALUE)
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 581, Short.MAX_VALUE)
                    .addComponent(PanelFuncion, javax.swing.GroupLayout.DEFAULT_SIZE, 581, Short.MAX_VALUE)))
        );
    }// </editor-fold>//GEN-END:initComponents

    /**
     * Metodo encargado de proveer el cambio de cartas en el distribuidor que
     * <br>contiene los paneles de metodos de la aplicacion.
     * @param card el numero constante que recibe este metodo y que usa para determinar que carta cambiar
     */
    public void cardChanger(int card) {
        cl = (CardLayout) PanelFuncion.getLayout();
        switch (card) {
            case (PanelMain.ECUACIONES): {
                cl.show(PanelFuncion, "Ecuaciones");
                break;
            }
            case (PanelMain.MATRICES): {
                cl.show(PanelFuncion, "Matriz");

                break;
            }
            case (PanelMain.INTERPOLACION): {
                cl.show(PanelFuncion, "Interpolacion");

                break;
            }
            case (PanelMain.INCREMENTALES): {
                cl.show(PanelFuncion, "Incrementales");
                panelIncrementales.updateFunctions();
                break;
            }
            case (PanelMain.BISECCION): {
                cl.show(PanelFuncion, "Biseccion");
                panelBiseccion.updateFunctions();
                break;
            }
            case (PanelMain.PUNTO_FIJO): {
                cl.show(PanelFuncion, "PuntoFijo");
                panelPuntoFijo.updateFunctions();
                break;
            }
            case (PanelMain.REGLA_FALSA): {
                cl.show(PanelFuncion, "ReglaFalsa");
                panelReglaFalsa.updateFunctions();
                break;
            }
            case (PanelMain.NEWTON): {
                cl.show(PanelFuncion, "Newton");
                panelNewton.updateFunctions();
                break;
            }
            case (PanelMain.SECANTE): {
                cl.show(PanelFuncion, "Secante");
                panelSecante.updateFunctions();
                break;
            }
            case (PanelMain.RAICES_MULTIPLES): {
                cl.show(PanelFuncion, "Raices");
                panelRaices.updateFunctions();
                break;
            }
            case (PanelMain.ELIMINACION_GAUSSIANA): {
                cl.show(PanelFuncion, "EliminacionGaussiana");
                panelEliminacionGaussiana.updateTableModels();
                break;
            }
            case (PanelMain.FACTORIZACION_LU): {
                cl.show(PanelFuncion, "FactorizacionLU");
                panelFactorizacionLU.updateTableModels();
                break;
            }
            case (PanelMain.ITERATIVOS_ABIERTOS): {
                cl.show(PanelFuncion, "IterativosAbiertos");
                panelIterativosAbiertos.updateTableModels();
                break;
            }
            case (PanelMain.INTER_NEWTON): {
                cl.show(PanelFuncion, "InterNewton");
                panelInterNewton.updateTableModels();
                break;
            }
            case (PanelMain.LAGRANGE): {
                cl.show(PanelFuncion, "Lagrange");
                panelLagrange.updateTableModels();
                break;
            }
            case (PanelMain.SPLINES_LINEALES): {
                cl.show(PanelFuncion, "SplinesLineales");
                panelSplinesLineales.updateTableModels();
                break;
            }
            case (PanelMain.SPLINES_CUADRATICOS): {
                cl.show(PanelFuncion, "SplinesCuadraticos");
                panelSplinesCuadraticos.updateTableModels();
                break;
            }
            case (PanelMain.SPLINES_CUBICOS): {
                cl.show(PanelFuncion, "SplinesCubicos");
                panelSplinesCubicos.updateTableModels();
                break;
            }

        }
    }

    public void setLinksColor(Color c) {
        XLinkEcuaciones.setClickedColor(c);
        XLinkEcuaciones.setUnclickedColor(c);
        XLinkIncrementales.setUnclickedColor(c);
        XLinkIncrementales.setClickedColor(c);
        XLinkBiseccion.setClickedColor(c);
        XLinkBiseccion.setUnclickedColor(c);
        XLinkReglaFalsa.setClickedColor(c);
        XLinkReglaFalsa.setUnclickedColor(c);
        XLinkPuntoFijo.setClickedColor(c);
        XLinkPuntoFijo.setUnclickedColor(c);
        XLinkNewton.setUnclickedColor(c);
        XLinkNewton.setClickedColor(c);
        XLinkSecante.setClickedColor(c);
        XLinkSecante.setUnclickedColor(c);
        XLinkRaicesMultiples.setClickedColor(c);
        XLinkRaicesMultiples.setUnclickedColor(c);
        XLinkMatriz.setUnclickedColor(c);
        XLinkMatriz.setClickedColor(c);
        XLinkEliminacionGaussiana.setClickedColor(c);
        XLinkEliminacionGaussiana.setUnclickedColor(c);
        XLinkFactorizacionLU.setClickedColor(c);
        XLinkFactorizacionLU.setUnclickedColor(c);
        XLinkIterativosAbiertos.setClickedColor(c);
        XLinkIterativosAbiertos.setUnclickedColor(c);
        XLinkInterpolacion.setClickedColor(c);
        XLinkInterpolacion.setUnclickedColor(c);
        XLinkInterNewton.setClickedColor(c);
        XLinkInterNewton.setUnclickedColor(c);
        XLinkLagrange.setClickedColor(c);
        XLinkLagrange.setUnclickedColor(c);
        XLinkSplinesLineales.setUnclickedColor(c);
        XLinkSplinesLineales.setClickedColor(c);
        XLinkSplinesCuadraticos.setClickedColor(c);
        XLinkSplinesCuadraticos.setUnclickedColor(c);
        XLinkSplinesCubicos.setClickedColor(c);
        XLinkSplinesCubicos.setUnclickedColor(c);

        returns.setClickedColor(c);
        returns.setUnclickedColor(c);
    }

    /**
     * Metodo que maneja el cambio de "carta" en el sistema.
     * @param e
     */
    public void actionPerformed(ActionEvent e) {

        String action = e.getActionCommand();
        if (action.equalsIgnoreCase("Ecuaciones")) {
            cardChanger(PanelMain.ECUACIONES);
        } else if (action.equalsIgnoreCase("Matriz")) {
            cardChanger(PanelMain.MATRICES);
        } else if (action.equalsIgnoreCase("Interpolacion")) {
            cardChanger(PanelMain.INTERPOLACION);
        } else if (action.equalsIgnoreCase("Biseccion")) {
            cardChanger(PanelMain.BISECCION);
        } else if (action.equalsIgnoreCase("Incrementales")) {
            cardChanger(PanelMain.INCREMENTALES);
        } else if (action.equalsIgnoreCase("ReglaFalsa")) {
            cardChanger(PanelMain.REGLA_FALSA);
        } else if (action.equalsIgnoreCase("PuntoFijo")) {
            cardChanger(PanelMain.PUNTO_FIJO);
        } else if (action.equalsIgnoreCase("Newton")) {
            cardChanger(PanelMain.NEWTON);
        } else if (action.equalsIgnoreCase("Secante")) {
            cardChanger(PanelMain.SECANTE);
        } else if (action.equalsIgnoreCase("RaicesMultiples")) {
            cardChanger(PanelMain.RAICES_MULTIPLES);
        } else if (action.equalsIgnoreCase("EliminacionGaussiana")) {
            cardChanger(PanelMain.ELIMINACION_GAUSSIANA);
        } else if (action.equalsIgnoreCase("FactorizacionLU")) {
            cardChanger(PanelMain.FACTORIZACION_LU);
        } else if (action.equalsIgnoreCase("IterativosAbiertos")) {
            cardChanger(PanelMain.ITERATIVOS_ABIERTOS);
        } else if (action.equalsIgnoreCase("InterNewton")) {
            cardChanger(PanelMain.INTER_NEWTON);
        } else if (action.equalsIgnoreCase("Lagrange")) {
            cardChanger(PanelMain.LAGRANGE);
        } else if (action.equalsIgnoreCase("SplinesLineales")) {
            cardChanger(PanelMain.SPLINES_LINEALES);
        } else if (action.equalsIgnoreCase("SplinesCuadraticos")) {
            cardChanger(PanelMain.SPLINES_CUADRATICOS);
        } else if (action.equalsIgnoreCase("SplinesCubicos")) {
            cardChanger(PanelMain.SPLINES_CUBICOS);
        } //caso Especial para el retorno hacia el panel de bienvenida
        else if (action.equalsIgnoreCase("return")) {
            parent.panelChanger(NuMethodApp.WELCOME);
        }

    }

    public final void initComponents2() {

        TaskPaneNoLineales = new JXTaskPane();
        TaskPaneSisEcuaciones = new JXTaskPane();
        TaskPaneInterpolacion = new JXTaskPane();

        //--------------------------------------
        //Construccion de los Hyperlinks que generaran los eventos de cambio de carta
        //----------------------------------------
        XLinkEcuaciones = new JXHyperlink();
        XLinkEcuaciones.setText("Ecuaciones");
        XLinkEcuaciones.setClickedColor(Color.DARK_GRAY);
        XLinkEcuaciones.setUnclickedColor(Color.DARK_GRAY);

        XLinkEcuaciones.setActionCommand("Ecuaciones");
        XLinkEcuaciones.addActionListener(this);
        //------------------------------------
        XLinkMatriz = new JXHyperlink();
        XLinkMatriz.setText("Sistemas de ecuaciones");
        XLinkMatriz.setClickedColor(Color.DARK_GRAY);
        XLinkMatriz.setUnclickedColor(Color.DARK_GRAY);

        XLinkMatriz.setActionCommand("Matriz");
        XLinkMatriz.addActionListener(this);

        //----------------------------------------
        XLinkInterpolacion = new JXHyperlink();
        XLinkInterpolacion.setText("Interpolacion");
        XLinkInterpolacion.setClickedColor(Color.DARK_GRAY);
        XLinkInterpolacion.setUnclickedColor(Color.DARK_GRAY);

        XLinkInterpolacion.setActionCommand("Interpolacion");
        XLinkInterpolacion.addActionListener(this);

        //----------------------------------------
//Edcuaciones no lineales
        XLinkIncrementales = new JXHyperlink();
        XLinkIncrementales.setText("Busquedas Incrementales");
        XLinkIncrementales.setClickedColor(Color.DARK_GRAY);
        XLinkIncrementales.setUnclickedColor(Color.darkGray);

        XLinkIncrementales.setActionCommand("Incrementales");
        XLinkIncrementales.addActionListener(this);

        //------------------------------------
        XLinkBiseccion = new JXHyperlink();
        XLinkBiseccion.setText("Biseccion");
        XLinkBiseccion.setClickedColor(Color.DARK_GRAY);
        XLinkBiseccion.setUnclickedColor(Color.DARK_GRAY);

        XLinkBiseccion.setActionCommand("Biseccion");
        XLinkBiseccion.addActionListener(this);
        //--------------------------------------
        XLinkReglaFalsa = new JXHyperlink();
        XLinkReglaFalsa.setText("Regla Falsa");
        XLinkReglaFalsa.setClickedColor(Color.DARK_GRAY);
        XLinkReglaFalsa.setUnclickedColor(Color.DARK_GRAY);

        XLinkReglaFalsa.setActionCommand("ReglaFalsa");
        XLinkReglaFalsa.addActionListener(this);

        //----------------------------------------
        XLinkPuntoFijo = new JXHyperlink();
        XLinkPuntoFijo.setText("Punto Fijo");
        XLinkPuntoFijo.setClickedColor(Color.DARK_GRAY);
        XLinkPuntoFijo.setUnclickedColor(Color.DARK_GRAY);

        XLinkPuntoFijo.setActionCommand("PuntoFijo");
        XLinkPuntoFijo.addActionListener(this);
        //--------------------------------------
        XLinkNewton = new JXHyperlink();
        XLinkNewton.setText("Newton");
        XLinkNewton.setToolTipText("Muestra el panel para ejecutar el metodo de newton");
        XLinkNewton.setClickedColor(Color.DARK_GRAY);
        XLinkNewton.setUnclickedColor(Color.DARK_GRAY);

        XLinkNewton.setActionCommand("Newton");
        XLinkNewton.addActionListener(this);
        //----------------------------------------
        XLinkSecante = new JXHyperlink();
        XLinkSecante.setText("Secante");
        XLinkSecante.setClickedColor(Color.DARK_GRAY);
        XLinkSecante.setUnclickedColor(Color.DARK_GRAY);

        XLinkSecante.setActionCommand("Secante");
        XLinkSecante.addActionListener(this);
        //----------------------------------------
        XLinkRaicesMultiples = new JXHyperlink();
        XLinkRaicesMultiples.setText("Raices Multiples");
        XLinkRaicesMultiples.setClickedColor(Color.DARK_GRAY);
        XLinkRaicesMultiples.setUnclickedColor(Color.DARK_GRAY);

        XLinkRaicesMultiples.setActionCommand("RaicesMultiples");
        XLinkRaicesMultiples.addActionListener(this);
        //--------------------------------------
//Sistemas de Ecuaciones
        XLinkEliminacionGaussiana = new JXHyperlink();
        XLinkEliminacionGaussiana.setText("Eliminacion Gaussiana");
        XLinkEliminacionGaussiana.setClickedColor(Color.DARK_GRAY);
        XLinkEliminacionGaussiana.setUnclickedColor(Color.DARK_GRAY);

        XLinkEliminacionGaussiana.setActionCommand("EliminacionGaussiana");
        XLinkEliminacionGaussiana.addActionListener(this);
        //--------------------------------------
        XLinkFactorizacionLU = new JXHyperlink();
        XLinkFactorizacionLU.setText("Factorizacion LU");
        XLinkFactorizacionLU.setClickedColor(Color.DARK_GRAY);
        XLinkFactorizacionLU.setUnclickedColor(Color.DARK_GRAY);

        XLinkFactorizacionLU.setActionCommand("FactorizacionLU");
        XLinkFactorizacionLU.addActionListener(this);
        //--------------------------------------
        XLinkIterativosAbiertos = new JXHyperlink();
        XLinkIterativosAbiertos.setText("Metodos Iterativos Abiertos");
        XLinkIterativosAbiertos.setClickedColor(Color.DARK_GRAY);
        XLinkIterativosAbiertos.setUnclickedColor(Color.DARK_GRAY);

        XLinkIterativosAbiertos.setActionCommand("IterativosAbiertos");
        XLinkIterativosAbiertos.addActionListener(this);
        //--------------------------------------
//interpolacion
        XLinkInterNewton = new JXHyperlink();
        XLinkInterNewton.setText("Interpolacion por Newton");
        XLinkInterNewton.setClickedColor(Color.DARK_GRAY);
        XLinkInterNewton.setUnclickedColor(Color.DARK_GRAY);

        XLinkInterNewton.setActionCommand("InterNewton");
        XLinkInterNewton.addActionListener(this);
        //--------------------------------------
        XLinkLagrange = new JXHyperlink();
        XLinkLagrange.setText("Metodo de Lagrange");
        XLinkLagrange.setClickedColor(Color.DARK_GRAY);
        XLinkLagrange.setUnclickedColor(Color.DARK_GRAY);

        XLinkLagrange.setActionCommand("Lagrange");
        XLinkLagrange.addActionListener(this);
        //--------------------------------------
        XLinkSplinesLineales = new JXHyperlink();
        XLinkSplinesLineales.setText("Metodo de los Splines Lineales");
        XLinkSplinesLineales.setClickedColor(Color.DARK_GRAY);
        XLinkSplinesLineales.setUnclickedColor(Color.DARK_GRAY);

        XLinkSplinesLineales.setActionCommand("SplinesLineales");
        XLinkSplinesLineales.addActionListener(this);
        //--------------------------------------
        XLinkSplinesCuadraticos = new JXHyperlink();
        XLinkSplinesCuadraticos.setText("Metodo de los Splines Cuadraticos");
        XLinkSplinesCuadraticos.setClickedColor(Color.DARK_GRAY);
        XLinkSplinesCuadraticos.setUnclickedColor(Color.DARK_GRAY);

        XLinkSplinesCuadraticos.setActionCommand("SplinesCuadraticos");
        XLinkSplinesCuadraticos.addActionListener(this);
        //--------------------------------------
        XLinkSplinesCubicos = new JXHyperlink();
        XLinkSplinesCubicos.setText("Metodo de los Splines Cubicos");
        XLinkSplinesCubicos.setClickedColor(Color.DARK_GRAY);
        XLinkSplinesCubicos.setUnclickedColor(Color.DARK_GRAY);

        XLinkSplinesCubicos.setActionCommand("SplinesCubicos");
        XLinkSplinesCubicos.addActionListener(this);
        //--------------------------------------



        //Metodos de Construccion de los objetos TaskPane
        TaskPaneNoLineales.setTitle("Ecuaciones no Lineales");
        TaskPaneNoLineales.setAnimated(true);
        TaskPaneNoLineales.setCollapsed(true);

        TaskPaneNoLineales.add(XLinkEcuaciones);
        TaskPaneNoLineales.add(new JSeparator(JSeparator.HORIZONTAL));
        TaskPaneNoLineales.add(XLinkIncrementales);
        TaskPaneNoLineales.add(XLinkBiseccion);
        TaskPaneNoLineales.add(XLinkReglaFalsa);
        TaskPaneNoLineales.add(new JSeparator(JSeparator.HORIZONTAL));
        TaskPaneNoLineales.add(XLinkPuntoFijo);
        TaskPaneNoLineales.add(XLinkNewton);
        TaskPaneNoLineales.add(XLinkSecante);
        TaskPaneNoLineales.add(XLinkRaicesMultiples);
        //-----------------------------------------
        TaskPaneSisEcuaciones.setTitle("Sistemas de Ecuaciones");
        TaskPaneSisEcuaciones.setCollapsed(true);
        TaskPaneSisEcuaciones.setAnimated(true);

        TaskPaneSisEcuaciones.add(XLinkMatriz);
        TaskPaneSisEcuaciones.add(XLinkEliminacionGaussiana);
        TaskPaneSisEcuaciones.add(XLinkFactorizacionLU);
        TaskPaneSisEcuaciones.add(XLinkIterativosAbiertos);
        //-----------------------------------------
        TaskPaneInterpolacion.setTitle("Interpolación");
        TaskPaneInterpolacion.setCollapsed(true);
        TaskPaneInterpolacion.setAnimated(true);

        TaskPaneInterpolacion.add(XLinkInterpolacion);
        TaskPaneInterpolacion.add(XLinkInterNewton);
        TaskPaneInterpolacion.add(XLinkLagrange);
        TaskPaneInterpolacion.add(new JSeparator(JSeparator.HORIZONTAL));
        TaskPaneInterpolacion.add(XLinkSplinesLineales);
        TaskPaneInterpolacion.add(XLinkSplinesCuadraticos);
        TaskPaneInterpolacion.add(XLinkSplinesCubicos);
        //******
        //Construccion del Hyperlink que retorna al panel de inicio
        returns = new JXHyperlink();
        returns.setText("Volver al inicio");
        returns.setClickedColor(Color.DARK_GRAY);
        returns.setUnclickedColor(Color.DARK_GRAY);

        returns.setActionCommand("return");
        returns.addActionListener(this);
        //******

        //--------------------------------------------
        //Agregar componentes al container padre
        TaskContainer.add(TaskPaneNoLineales);
        TaskContainer.add(TaskPaneSisEcuaciones);
        TaskContainer.add(TaskPaneInterpolacion);
        TaskContainer.add(returns);



        //***************************
        // COmponentes que contendra el panel de las funciones
        // cada uno de estos paneles es construido por fuera e integrado aqui al sistema principal
        panelEcuaciones = new PanelEcuaciones();
        panelBiseccion = new PanelBiseccion();
        panelReglaFalsa = new PanelReglaFalsa();
        panelIncrementales = new PanelIncrementales();
        panelPuntoFijo = new PanelPuntoFijo();
        panelNewton = new PanelNewton();
        panelSecante = new PanelSecante();
        panelRaices = new PanelRaices();

        panelMatriz = new PanelMatriz();
        panelEliminacionGaussiana = new PanelEliminacionGaussiana();
        panelFactorizacionLU = new PanelFactorizacionLU();
        panelIterativosAbiertos = new PanelIterativosAbiertos();

        panelInterpolacion = new PanelInterpolacion();
        panelInterNewton = new PanelInterNewton(parent);
        panelLagrange = new PanelLagrange(parent);
        panelSplinesLineales = new PanelSplinesLineales(parent);
        panelSplinesCuadraticos = new PanelSplinesCuadraticos(parent);
        panelSplinesCubicos = new PanelSplinesCubicos(parent);

        //Panel funcion es el panel que contendra las cartas del cardLayout
        // Cada linea de las siguientes permite agregar un JCOmponent ya construido
        // al panel que contendra la distribucion por cartas
        // La linea de abajo, es un agregador de contenido a un component (PanelFuncion)
        // Con un parametro en String "ECUACIONES" el parametro es usado por el cardLayout para determinar que carta (componente) mostrar
        // PanelFuncion.add(panelEcuaciones, "ECUACIONES");

        PanelFuncion.add(panelEcuaciones, "Ecuaciones");
        PanelFuncion.add(panelIncrementales, "Incrementales");
        PanelFuncion.add(panelBiseccion, "Biseccion");
        PanelFuncion.add(panelReglaFalsa, "ReglaFalsa");

        PanelFuncion.add(panelPuntoFijo, "PuntoFijo");
        PanelFuncion.add(panelNewton, "Newton");
        PanelFuncion.add(panelSecante, "Secante");
        PanelFuncion.add(panelRaices, "Raices");

        PanelFuncion.add(panelEliminacionGaussiana, "EliminacionGaussiana");
        PanelFuncion.add(panelFactorizacionLU, "FactorizacionLU");
        PanelFuncion.add(panelIterativosAbiertos, "IterativosAbiertos");


        PanelFuncion.add(panelInterpolacion, "Interpolacion");
        PanelFuncion.add(panelInterNewton, "InterNewton");
        PanelFuncion.add(panelLagrange, "Lagrange");
        PanelFuncion.add(panelSplinesLineales, "SplinesLineales");
        PanelFuncion.add(panelSplinesCuadraticos, "SplinesCuadraticos");
        PanelFuncion.add(panelSplinesCubicos, "SplinesCubicos");


        //Codigo para agregar el soporte grafico a la matriz
        PanelFuncion.add(panelMatriz, "Matriz");
        //********************
    } //Fin del metodo que completa la interfaz
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JPanel PanelFuncion;
    private org.jdesktop.swingx.JXTaskPaneContainer TaskContainer;
    private javax.swing.JScrollPane jScrollPane1;
    // End of variables declaration//GEN-END:variables
}
